YES 2.79 H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/List.hs
H-Termination of the given Haskell-Program with start terms could successfully be proven:



HASKELL
  ↳ LR

mainModule List
  ((elemIndices :: Eq a => [a ->  [[a]]  ->  [Int]) :: Eq a => [a ->  [[a]]  ->  [Int])

module List where
  import qualified Maybe
import qualified Prelude

  elemIndices :: Eq a => a  ->  [a ->  [Int]
elemIndices x findIndices (== x)

  findIndices :: (a  ->  Bool ->  [a ->  [Int]
findIndices p xs concatMap (\vv1 ->
case vv1 of
  (x,i)->  if p x then i : [] else []
  _-> []
) (zip xs (enumFrom 0))


module Maybe where
  import qualified List
import qualified Prelude



Lambda Reductions:
The following Lambda expression
\vv1
case vv1 of
 (x,i) → if p x then i : [] else []
 _ → []

is transformed to
findIndices0 p vv1 = 
case vv1 of
 (x,i) → if p x then i : [] else []
 _ → []

The following Lambda expression
\ab→(a,b)

is transformed to
zip0 a b = (a,b)



↳ HASKELL
  ↳ LR
HASKELL
      ↳ CR

mainModule List
  ((elemIndices :: Eq a => [a ->  [[a]]  ->  [Int]) :: Eq a => [a ->  [[a]]  ->  [Int])

module List where
  import qualified Maybe
import qualified Prelude

  elemIndices :: Eq a => a  ->  [a ->  [Int]
elemIndices x findIndices (== x)

  findIndices :: (a  ->  Bool ->  [a ->  [Int]
findIndices p xs concatMap (findIndices0 p) (zip xs (enumFrom 0))

  
findIndices0 p vv1 
case vv1 of
  (x,i)->  if p x then i : [] else []
  _-> []


module Maybe where
  import qualified List
import qualified Prelude



Case Reductions:
The following Case expression
case vv1 of
 (x,i) → if p x then i : [] else []
 _ → []

is transformed to
findIndices00 p (x,i) = if p x then i : [] else []
findIndices00 p _ = []



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
HASKELL
          ↳ IFR

mainModule List
  ((elemIndices :: Eq a => [a ->  [[a]]  ->  [Int]) :: Eq a => [a ->  [[a]]  ->  [Int])

module List where
  import qualified Maybe
import qualified Prelude

  elemIndices :: Eq a => a  ->  [a ->  [Int]
elemIndices x findIndices (== x)

  findIndices :: (a  ->  Bool ->  [a ->  [Int]
findIndices p xs concatMap (findIndices0 p) (zip xs (enumFrom 0))

  
findIndices0 p vv1 findIndices00 p vv1

  
findIndices00 p (x,i if p x then i : [] else []
findIndices00 p _ []


module Maybe where
  import qualified List
import qualified Prelude



If Reductions:
The following If expression
if p x then i : [] else []

is transformed to
findIndices000 i True = i : []
findIndices000 i False = []



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
HASKELL
              ↳ BR

mainModule List
  ((elemIndices :: Eq a => [a ->  [[a]]  ->  [Int]) :: Eq a => [a ->  [[a]]  ->  [Int])

module List where
  import qualified Maybe
import qualified Prelude

  elemIndices :: Eq a => a  ->  [a ->  [Int]
elemIndices x findIndices (== x)

  findIndices :: (a  ->  Bool ->  [a ->  [Int]
findIndices p xs concatMap (findIndices0 p) (zip xs (enumFrom 0))

  
findIndices0 p vv1 findIndices00 p vv1

  
findIndices00 p (x,ifindIndices000 i (p x)
findIndices00 p _ []

  
findIndices000 i True i : []
findIndices000 i False []


module Maybe where
  import qualified List
import qualified Prelude



Replaced joker patterns by fresh variables and removed binding patterns.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
HASKELL
                  ↳ COR

mainModule List
  ((elemIndices :: Eq a => [a ->  [[a]]  ->  [Int]) :: Eq a => [a ->  [[a]]  ->  [Int])

module List where
  import qualified Maybe
import qualified Prelude

  elemIndices :: Eq a => a  ->  [a ->  [Int]
elemIndices x findIndices (== x)

  findIndices :: (a  ->  Bool ->  [a ->  [Int]
findIndices p xs concatMap (findIndices0 p) (zip xs (enumFrom 0))

  
findIndices0 p vv1 findIndices00 p vv1

  
findIndices00 p (x,ifindIndices000 i (p x)
findIndices00 p vw []

  
findIndices000 i True i : []
findIndices000 i False []


module Maybe where
  import qualified List
import qualified Prelude



Cond Reductions:
The following Function with conditions
undefined 
 | False
 = undefined

is transformed to
undefined  = undefined1

undefined0 True = undefined

undefined1  = undefined0 False



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
HASKELL
                      ↳ NumRed

mainModule List
  ((elemIndices :: Eq a => [a ->  [[a]]  ->  [Int]) :: Eq a => [a ->  [[a]]  ->  [Int])

module List where
  import qualified Maybe
import qualified Prelude

  elemIndices :: Eq a => a  ->  [a ->  [Int]
elemIndices x findIndices (== x)

  findIndices :: (a  ->  Bool ->  [a ->  [Int]
findIndices p xs concatMap (findIndices0 p) (zip xs (enumFrom 0))

  
findIndices0 p vv1 findIndices00 p vv1

  
findIndices00 p (x,ifindIndices000 i (p x)
findIndices00 p vw []

  
findIndices000 i True i : []
findIndices000 i False []


module Maybe where
  import qualified List
import qualified Prelude



Num Reduction: All numbers are transformed to thier corresponding representation with Pos, Neg, Succ and Zero.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ NumRed
HASKELL
                          ↳ Narrow

mainModule List
  (elemIndices :: Eq a => [a ->  [[a]]  ->  [Int])

module List where
  import qualified Maybe
import qualified Prelude

  elemIndices :: Eq a => a  ->  [a ->  [Int]
elemIndices x findIndices (== x)

  findIndices :: (a  ->  Bool ->  [a ->  [Int]
findIndices p xs concatMap (findIndices0 p) (zip xs (enumFrom (Pos Zero)))

  
findIndices0 p vv1 findIndices00 p vv1

  
findIndices00 p (x,ifindIndices000 i (p x)
findIndices00 p vw []

  
findIndices000 i True i : []
findIndices000 i False []


module Maybe where
  import qualified List
import qualified Prelude



Haskell To QDPs


↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
QDP
                                ↳ QDPSizeChangeProof
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primPlusNat(Succ(yu5600), Succ(yu411001000)) → new_primPlusNat(yu5600, yu411001000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
QDP
                                ↳ QDPSizeChangeProof
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primMulNat(Succ(yu30100), Succ(yu41100100)) → new_primMulNat(yu30100, Succ(yu41100100))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
QDP
                                ↳ QDPSizeChangeProof
                              ↳ QDP
                              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primEqNat(Succ(yu3000), Succ(yu4110000)) → new_primEqNat(yu3000, yu4110000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
QDP
                                ↳ QDPSizeChangeProof
                              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_esEs2(Just(yu300), Just(yu411000), app(app(app(ty_@3, baa), bab), bac)) → new_esEs1(yu300, yu411000, baa, bab, bac)
new_esEs(@2(yu300, yu301), @2(yu411000, yu411001), app(app(ty_@2, ba), bb), bc) → new_esEs(yu300, yu411000, ba, bb)
new_esEs(@2(yu300, yu301), @2(yu411000, yu411001), app(ty_[], bd), bc) → new_esEs0(yu300, yu411000, bd)
new_esEs1(@3(yu300, yu301, yu302), @3(yu411000, yu411001, yu411002), fb, app(app(app(ty_@3, fg), fh), ga), eb) → new_esEs1(yu301, yu411001, fg, fh, ga)
new_esEs1(@3(yu300, yu301, yu302), @3(yu411000, yu411001, yu411002), fb, app(app(ty_Either, gc), gd), eb) → new_esEs3(yu301, yu411001, gc, gd)
new_esEs0(:(Left(yu300), yu31), :(Left(yu411000), yu41101), app(app(ty_Either, app(app(ty_Either, bbg), bbh)), bba)) → new_esEs3(yu300, yu411000, bbg, bbh)
new_esEs0(:(@3(yu300, yu301, yu302), yu31), :(@3(yu411000, yu411001, yu411002), yu41101), app(app(app(ty_@3, app(ty_[], ec)), ea), eb)) → new_esEs0(yu300, yu411000, ec)
new_esEs1(@3(yu300, yu301, yu302), @3(yu411000, yu411001, yu411002), app(ty_[], ec), ea, eb) → new_esEs0(yu300, yu411000, ec)
new_esEs3(Right(yu300), Right(yu411000), bca, app(app(ty_Either, bda), bdb)) → new_esEs3(yu300, yu411000, bda, bdb)
new_esEs0(:(Left(yu300), yu31), :(Left(yu411000), yu41101), app(app(ty_Either, app(ty_Maybe, bbf)), bba)) → new_esEs2(yu300, yu411000, bbf)
new_esEs1(@3(yu300, yu301, yu302), @3(yu411000, yu411001, yu411002), fb, ea, app(app(app(ty_@3, gh), ha), hb)) → new_esEs1(yu302, yu411002, gh, ha, hb)
new_esEs0(:(@3(yu300, yu301, yu302), yu31), :(@3(yu411000, yu411001, yu411002), yu41101), app(app(app(ty_@3, fb), ea), app(ty_[], gg))) → new_esEs0(yu302, yu411002, gg)
new_esEs3(Left(yu300), Left(yu411000), app(app(app(ty_@3, bbc), bbd), bbe), bba) → new_esEs1(yu300, yu411000, bbc, bbd, bbe)
new_esEs0(:(@2(yu300, yu301), yu31), :(@2(yu411000, yu411001), yu41101), app(app(ty_@2, app(app(ty_Either, ca), cb)), bc)) → new_esEs3(yu300, yu411000, ca, cb)
new_esEs2(Just(yu300), Just(yu411000), app(ty_Maybe, bad)) → new_esEs2(yu300, yu411000, bad)
new_esEs0(:(@3(yu300, yu301, yu302), yu31), :(@3(yu411000, yu411001, yu411002), yu41101), app(app(app(ty_@3, fb), app(app(ty_Either, gc), gd)), eb)) → new_esEs3(yu301, yu411001, gc, gd)
new_esEs3(Left(yu300), Left(yu411000), app(app(ty_Either, bbg), bbh), bba) → new_esEs3(yu300, yu411000, bbg, bbh)
new_esEs0(:(Just(yu300), yu31), :(Just(yu411000), yu41101), app(ty_Maybe, app(app(ty_@2, hf), hg))) → new_esEs(yu300, yu411000, hf, hg)
new_esEs0(:(Right(yu300), yu31), :(Right(yu411000), yu41101), app(app(ty_Either, bca), app(ty_[], bcd))) → new_esEs0(yu300, yu411000, bcd)
new_esEs1(@3(yu300, yu301, yu302), @3(yu411000, yu411001, yu411002), fb, ea, app(app(ty_@2, ge), gf)) → new_esEs(yu302, yu411002, ge, gf)
new_esEs0(:(@3(yu300, yu301, yu302), yu31), :(@3(yu411000, yu411001, yu411002), yu41101), app(app(app(ty_@3, app(app(app(ty_@3, ed), ee), ef)), ea), eb)) → new_esEs1(yu300, yu411000, ed, ee, ef)
new_esEs1(@3(yu300, yu301, yu302), @3(yu411000, yu411001, yu411002), fb, ea, app(ty_[], gg)) → new_esEs0(yu302, yu411002, gg)
new_esEs(@2(yu300, yu301), @2(yu411000, yu411001), app(app(ty_Either, ca), cb), bc) → new_esEs3(yu300, yu411000, ca, cb)
new_esEs0(:(Just(yu300), yu31), :(Just(yu411000), yu41101), app(ty_Maybe, app(ty_Maybe, bad))) → new_esEs2(yu300, yu411000, bad)
new_esEs3(Left(yu300), Left(yu411000), app(ty_[], bbb), bba) → new_esEs0(yu300, yu411000, bbb)
new_esEs2(Just(yu300), Just(yu411000), app(app(ty_@2, hf), hg)) → new_esEs(yu300, yu411000, hf, hg)
new_esEs(@2(yu300, yu301), @2(yu411000, yu411001), cc, app(app(ty_Either, dd), de)) → new_esEs3(yu301, yu411001, dd, de)
new_esEs3(Right(yu300), Right(yu411000), bca, app(ty_[], bcd)) → new_esEs0(yu300, yu411000, bcd)
new_esEs1(@3(yu300, yu301, yu302), @3(yu411000, yu411001, yu411002), fb, app(ty_[], ff), eb) → new_esEs0(yu301, yu411001, ff)
new_esEs(@2(yu300, yu301), @2(yu411000, yu411001), cc, app(ty_[], cf)) → new_esEs0(yu301, yu411001, cf)
new_esEs0(:(Left(yu300), yu31), :(Left(yu411000), yu41101), app(app(ty_Either, app(app(app(ty_@3, bbc), bbd), bbe)), bba)) → new_esEs1(yu300, yu411000, bbc, bbd, bbe)
new_esEs0(:(@2(yu300, yu301), yu31), :(@2(yu411000, yu411001), yu41101), app(app(ty_@2, cc), app(ty_Maybe, dc))) → new_esEs2(yu301, yu411001, dc)
new_esEs(@2(yu300, yu301), @2(yu411000, yu411001), cc, app(app(ty_@2, cd), ce)) → new_esEs(yu301, yu411001, cd, ce)
new_esEs1(@3(yu300, yu301, yu302), @3(yu411000, yu411001, yu411002), app(ty_Maybe, eg), ea, eb) → new_esEs2(yu300, yu411000, eg)
new_esEs3(Right(yu300), Right(yu411000), bca, app(ty_Maybe, bch)) → new_esEs2(yu300, yu411000, bch)
new_esEs0(:(@3(yu300, yu301, yu302), yu31), :(@3(yu411000, yu411001, yu411002), yu41101), app(app(app(ty_@3, fb), app(ty_[], ff)), eb)) → new_esEs0(yu301, yu411001, ff)
new_esEs0(:(Right(yu300), yu31), :(Right(yu411000), yu41101), app(app(ty_Either, bca), app(app(ty_@2, bcb), bcc))) → new_esEs(yu300, yu411000, bcb, bcc)
new_esEs(@2(yu300, yu301), @2(yu411000, yu411001), app(app(app(ty_@3, be), bf), bg), bc) → new_esEs1(yu300, yu411000, be, bf, bg)
new_esEs0(:(@2(yu300, yu301), yu31), :(@2(yu411000, yu411001), yu41101), app(app(ty_@2, cc), app(app(ty_Either, dd), de))) → new_esEs3(yu301, yu411001, dd, de)
new_esEs0(:(Right(yu300), yu31), :(Right(yu411000), yu41101), app(app(ty_Either, bca), app(app(ty_Either, bda), bdb))) → new_esEs3(yu300, yu411000, bda, bdb)
new_esEs0(:(@3(yu300, yu301, yu302), yu31), :(@3(yu411000, yu411001, yu411002), yu41101), app(app(app(ty_@3, app(app(ty_Either, eh), fa)), ea), eb)) → new_esEs3(yu300, yu411000, eh, fa)
new_esEs2(Just(yu300), Just(yu411000), app(app(ty_Either, bae), baf)) → new_esEs3(yu300, yu411000, bae, baf)
new_esEs0(:(@2(yu300, yu301), yu31), :(@2(yu411000, yu411001), yu41101), app(app(ty_@2, app(ty_[], bd)), bc)) → new_esEs0(yu300, yu411000, bd)
new_esEs0(:(@2(yu300, yu301), yu31), :(@2(yu411000, yu411001), yu41101), app(app(ty_@2, app(app(app(ty_@3, be), bf), bg)), bc)) → new_esEs1(yu300, yu411000, be, bf, bg)
new_esEs0(:(Left(yu300), yu31), :(Left(yu411000), yu41101), app(app(ty_Either, app(ty_[], bbb)), bba)) → new_esEs0(yu300, yu411000, bbb)
new_esEs0(:(yu30, yu31), :(yu41100, yu41101), bdc) → new_esEs0(yu31, yu41101, bdc)
new_esEs0(:(@3(yu300, yu301, yu302), yu31), :(@3(yu411000, yu411001, yu411002), yu41101), app(app(app(ty_@3, fb), app(ty_Maybe, gb)), eb)) → new_esEs2(yu301, yu411001, gb)
new_esEs0(:(Just(yu300), yu31), :(Just(yu411000), yu41101), app(ty_Maybe, app(app(ty_Either, bae), baf))) → new_esEs3(yu300, yu411000, bae, baf)
new_esEs0(:(@2(yu300, yu301), yu31), :(@2(yu411000, yu411001), yu41101), app(app(ty_@2, cc), app(ty_[], cf))) → new_esEs0(yu301, yu411001, cf)
new_esEs0(:(Just(yu300), yu31), :(Just(yu411000), yu41101), app(ty_Maybe, app(ty_[], hh))) → new_esEs0(yu300, yu411000, hh)
new_esEs(@2(yu300, yu301), @2(yu411000, yu411001), cc, app(ty_Maybe, dc)) → new_esEs2(yu301, yu411001, dc)
new_esEs0(:(@2(yu300, yu301), yu31), :(@2(yu411000, yu411001), yu41101), app(app(ty_@2, cc), app(app(app(ty_@3, cg), da), db))) → new_esEs1(yu301, yu411001, cg, da, db)
new_esEs1(@3(yu300, yu301, yu302), @3(yu411000, yu411001, yu411002), fb, app(app(ty_@2, fc), fd), eb) → new_esEs(yu301, yu411001, fc, fd)
new_esEs1(@3(yu300, yu301, yu302), @3(yu411000, yu411001, yu411002), fb, ea, app(app(ty_Either, hd), he)) → new_esEs3(yu302, yu411002, hd, he)
new_esEs0(:(@3(yu300, yu301, yu302), yu31), :(@3(yu411000, yu411001, yu411002), yu41101), app(app(app(ty_@3, app(ty_Maybe, eg)), ea), eb)) → new_esEs2(yu300, yu411000, eg)
new_esEs3(Right(yu300), Right(yu411000), bca, app(app(app(ty_@3, bce), bcf), bcg)) → new_esEs1(yu300, yu411000, bce, bcf, bcg)
new_esEs3(Left(yu300), Left(yu411000), app(app(ty_@2, bag), bah), bba) → new_esEs(yu300, yu411000, bag, bah)
new_esEs0(:(Left(yu300), yu31), :(Left(yu411000), yu41101), app(app(ty_Either, app(app(ty_@2, bag), bah)), bba)) → new_esEs(yu300, yu411000, bag, bah)
new_esEs0(:(@3(yu300, yu301, yu302), yu31), :(@3(yu411000, yu411001, yu411002), yu41101), app(app(app(ty_@3, fb), ea), app(app(app(ty_@3, gh), ha), hb))) → new_esEs1(yu302, yu411002, gh, ha, hb)
new_esEs(@2(yu300, yu301), @2(yu411000, yu411001), cc, app(app(app(ty_@3, cg), da), db)) → new_esEs1(yu301, yu411001, cg, da, db)
new_esEs1(@3(yu300, yu301, yu302), @3(yu411000, yu411001, yu411002), app(app(app(ty_@3, ed), ee), ef), ea, eb) → new_esEs1(yu300, yu411000, ed, ee, ef)
new_esEs3(Left(yu300), Left(yu411000), app(ty_Maybe, bbf), bba) → new_esEs2(yu300, yu411000, bbf)
new_esEs1(@3(yu300, yu301, yu302), @3(yu411000, yu411001, yu411002), fb, app(ty_Maybe, gb), eb) → new_esEs2(yu301, yu411001, gb)
new_esEs0(:(@3(yu300, yu301, yu302), yu31), :(@3(yu411000, yu411001, yu411002), yu41101), app(app(app(ty_@3, fb), app(app(ty_@2, fc), fd)), eb)) → new_esEs(yu301, yu411001, fc, fd)
new_esEs2(Just(yu300), Just(yu411000), app(ty_[], hh)) → new_esEs0(yu300, yu411000, hh)
new_esEs1(@3(yu300, yu301, yu302), @3(yu411000, yu411001, yu411002), fb, ea, app(ty_Maybe, hc)) → new_esEs2(yu302, yu411002, hc)
new_esEs0(:(@3(yu300, yu301, yu302), yu31), :(@3(yu411000, yu411001, yu411002), yu41101), app(app(app(ty_@3, fb), app(app(app(ty_@3, fg), fh), ga)), eb)) → new_esEs1(yu301, yu411001, fg, fh, ga)
new_esEs(@2(yu300, yu301), @2(yu411000, yu411001), app(ty_Maybe, bh), bc) → new_esEs2(yu300, yu411000, bh)
new_esEs0(:(@2(yu300, yu301), yu31), :(@2(yu411000, yu411001), yu41101), app(app(ty_@2, cc), app(app(ty_@2, cd), ce))) → new_esEs(yu301, yu411001, cd, ce)
new_esEs0(:(Right(yu300), yu31), :(Right(yu411000), yu41101), app(app(ty_Either, bca), app(app(app(ty_@3, bce), bcf), bcg))) → new_esEs1(yu300, yu411000, bce, bcf, bcg)
new_esEs0(:(@2(yu300, yu301), yu31), :(@2(yu411000, yu411001), yu41101), app(app(ty_@2, app(ty_Maybe, bh)), bc)) → new_esEs2(yu300, yu411000, bh)
new_esEs0(:(@3(yu300, yu301, yu302), yu31), :(@3(yu411000, yu411001, yu411002), yu41101), app(app(app(ty_@3, fb), ea), app(app(ty_Either, hd), he))) → new_esEs3(yu302, yu411002, hd, he)
new_esEs1(@3(yu300, yu301, yu302), @3(yu411000, yu411001, yu411002), app(app(ty_Either, eh), fa), ea, eb) → new_esEs3(yu300, yu411000, eh, fa)
new_esEs0(:(yu30, yu31), :(yu41100, yu41101), app(ty_[], df)) → new_esEs0(yu30, yu41100, df)
new_esEs1(@3(yu300, yu301, yu302), @3(yu411000, yu411001, yu411002), app(app(ty_@2, dg), dh), ea, eb) → new_esEs(yu300, yu411000, dg, dh)
new_esEs0(:(Right(yu300), yu31), :(Right(yu411000), yu41101), app(app(ty_Either, bca), app(ty_Maybe, bch))) → new_esEs2(yu300, yu411000, bch)
new_esEs0(:(Just(yu300), yu31), :(Just(yu411000), yu41101), app(ty_Maybe, app(app(app(ty_@3, baa), bab), bac))) → new_esEs1(yu300, yu411000, baa, bab, bac)
new_esEs0(:(@3(yu300, yu301, yu302), yu31), :(@3(yu411000, yu411001, yu411002), yu41101), app(app(app(ty_@3, fb), ea), app(ty_Maybe, hc))) → new_esEs2(yu302, yu411002, hc)
new_esEs0(:(@2(yu300, yu301), yu31), :(@2(yu411000, yu411001), yu41101), app(app(ty_@2, app(app(ty_@2, ba), bb)), bc)) → new_esEs(yu300, yu411000, ba, bb)
new_esEs0(:(@3(yu300, yu301, yu302), yu31), :(@3(yu411000, yu411001, yu411002), yu41101), app(app(app(ty_@3, app(app(ty_@2, dg), dh)), ea), eb)) → new_esEs(yu300, yu411000, dg, dh)
new_esEs0(:(@3(yu300, yu301, yu302), yu31), :(@3(yu411000, yu411001, yu411002), yu41101), app(app(app(ty_@3, fb), ea), app(app(ty_@2, ge), gf))) → new_esEs(yu302, yu411002, ge, gf)
new_esEs3(Right(yu300), Right(yu411000), bca, app(app(ty_@2, bcb), bcc)) → new_esEs(yu300, yu411000, bcb, bcc)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
QDP
                                ↳ QDPSizeChangeProof

Q DP problem:
The TRS P consists of the following rules:

new_foldr(yu3, yu4110, :(yu41110, yu41111), yu54, yu55, ba) → new_foldr(yu3, yu41110, yu41111, new_primPlusNat0(yu54, Zero), new_primPlusNat0(yu54, Zero), ba)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, yu41100100) → Succ(yu41100100)
new_primPlusNat0(Succ(yu560), yu41100100) → Succ(Succ(new_primPlusNat1(yu560, yu41100100)))
new_primPlusNat1(Succ(yu5600), Zero) → Succ(yu5600)
new_primPlusNat1(Zero, Succ(yu411001000)) → Succ(yu411001000)
new_primPlusNat1(Succ(yu5600), Succ(yu411001000)) → Succ(Succ(new_primPlusNat1(yu5600, yu411001000)))
new_primPlusNat1(Zero, Zero) → Zero

The set Q consists of the following terms:

new_primPlusNat1(Succ(x0), Zero)
new_primPlusNat1(Succ(x0), Succ(x1))
new_primPlusNat0(Succ(x0), x1)
new_primPlusNat0(Zero, x0)
new_primPlusNat1(Zero, Succ(x0))
new_primPlusNat1(Zero, Zero)

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: